{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Soft Actor-Critic (SAC) with PyTorch\n",
    "\n",
    "In this notebook we will look at Soft Actor-Critic (SAC) algorithm using PyTorch. It builds on what we saw in `listing8_2` for TD3. However, it is not further improvement of TD3, rather something that came out in parallel of TD3.\n",
    "\n",
    "Click here to access the paper which proposed SAC originally: https://arxiv.org/pdf/1802.09477.pdf\n",
    "\n",
    "SAC forms a bridge between DDPG style deterministic policy gradients and stochastic policy optimization. \n",
    "\n",
    "##### SAC vs TD3\n",
    "\n",
    "Similar:\n",
    "1. Both use Mean Squared Bellman Error(MSBE) minimization towards a common target\n",
    "2. Common target is calculated using target Q networks which are obtained using polyack averaging\n",
    "3. Both use clipped double Q - minimum of two Q values to avoid overestimation\n",
    "\n",
    "Different:\n",
    "1. SAC uses entropy regularization which is absent in TD3\n",
    "2. In TD3 target-policy is used to calculate the next-state-actions while, in SAC we use **current policy** to get actions for next_states\n",
    "3. In TD3 target_policy uses smoothing by adding random noise to actions, However, in SAC the policy learnt is a stochastic one which provides a smoothing effect without any explicit noise addition.\n",
    "\n",
    "#### Q-Loss with Entropy-Regularization\n",
    "\n",
    "Entropy measures randomness in the distribution. Higher the entropy, higher (or flatter) is the distribution. A sharp peaked policy has all its probability centered around that peak and hence it will have low entropy. Entropy is given by:\n",
    "\n",
    "$$H(P) = \\underset{x \\sim P}{E}\\left[{-\\log P(x)}\\right] \\;\\;\\;\\;\\text{where P is distribution of random variable x}$$\n",
    "\n",
    "With entropy regularization, the policy is trained to maximize a trade-off between expected return and entropy with  $\\alpha$ controlling the trade-off. The updated maximization problem is:\n",
    "\n",
    "The policy is trained to maximize a trade-off between expected return and entropy, a measure of randomness in the policy.\n",
    "\n",
    "$$\\pi^* = \\arg \\max_{\\pi} \\underset{\\tau \\sim \\pi}{E}\\left[{ \\sum_{t=0}^{\\infty} \\gamma^t \\left( R(s_t, a_t, s_{t+1}) + \\alpha H(\\pi(\\cdot|s_t)) \\right)}\\right]$$\n",
    "\n",
    "In this setting, $V^{\\pi}$ is changed to include the entropy from every time step:\n",
    "\n",
    "$$V^{\\pi}(s) = \\underset{\\tau \\sim \\pi}{E} \\left[{ \\left. \\sum_{t=0}^{\\infty} \\gamma^t \\left( R(s_t, a_t, s_{t+1}) + \\alpha H\\left(\\pi(\\cdot|s_t)\\right) \\right) \\right| s_0 = s} \\right]$$\n",
    "\n",
    "and, $Q^{\\pi}$ is changed to include the entropy bonuses from every time step except the first:\n",
    "\n",
    "$$Q^{\\pi}(s,a) = \\underset{\\tau \\sim \\pi}{E}\\left[{ \\left. \\sum_{t=0}^{\\infty} \\gamma^t  R(s_t, a_t, s_{t+1}) + \\alpha \\sum_{t=1}^{\\infty} \\gamma^t H\\left(\\pi(\\cdot|s_t)\\right)\\right| s_0 = s, a_0 = a}\\right]$$\n",
    "\n",
    "With these definitions, $V^{\\pi}$ and $Q^{\\pi}$ are connected by:\n",
    "\n",
    "$$V^{\\pi}(s) = \\underset{a \\sim \\pi}{E}{Q^{\\pi}(s,a)} + \\alpha H\\left(\\pi(\\cdot|s)\\right)$$\n",
    "\n",
    "and the Bellman equation for $Q^{\\pi}$ is\n",
    "\n",
    "$$Q^{\\pi}(s,a) = \\underset{s' \\sim P \\\\ a' \\sim \\pi}E[\\left[{R(s,a,s') + \\gamma\\left(Q^{\\pi}(s',a') + \\alpha H\\left(\\pi(\\cdot|s')\\right) \\right)} \\right]\\\\\n",
    "= \\underset{s' \\sim P}E\\left[{R(s,a,s') + \\gamma V^{\\pi}(s')}\\right].$$\n",
    "\n",
    "The right hand side is an expectation which we will now convert into a sample estimate.\n",
    "\n",
    "\n",
    "$$Q^{\\pi}(s,a) \\approx r + \\gamma\\left(Q^{\\pi}(s',\\tilde{a}') - \\alpha \\log \\pi(\\tilde{a}'|s') \\right), \\;\\;\\;\\;\\;  \\tilde{a}' \\sim \\pi(\\cdot|s')$$\n",
    "\n",
    "where(s,a,r,s') come form replay buffer and $\\tilde{a}'$ comes from sampling the online/agent policy. In SAC, we do not use target network policy at all. \n",
    "\n",
    "\n",
    "Like TD3, SAC uses clipped Double Q and minimizes Mean Squared Bellman Error (MSBE). Putting it all together, the loss functions for the Q-networks in SAC are:\n",
    "\n",
    "$$L(\\phi_i, {\\mathcal D}) = \\underset{(s,a,r,s',d) \\sim {\\mathcal D}}{{\\mathrm E}}\\left[\n",
    "    \\left( Q_{\\phi_i}(s,a) - y(r,s',d) \\right)^2\n",
    "    \\right], \\;\\;\\;\\;\\; i=1,2$$\n",
    "    \n",
    "where the target is given by\n",
    "\n",
    "$$y(r, s', d) = r + \\gamma (1 - d) \\left( \\min_{i=1,2} Q_{\\phi_{\\text{targ},i}}(s', \\tilde{a}') - \\alpha \\log \\pi_{\\theta}(\\tilde{a}'|s') \\right), \\;\\;\\;\\;\\; \\tilde{a}' \\sim \\pi_{\\theta}(\\cdot|s')$$\n",
    "\n",
    "\n",
    "We now convert expectations to sample averages:\n",
    "\n",
    "$$L(\\phi_i, {\\mathcal D}) = \\frac{1}{|B|}\\sum_{(s,a,r,s',d) \\in B} \\left( Q_{\\phi_i}(s,a) - y(r,s',d) \\right)^2, \\;\\;\\;\\;\\; \\text{for } i=1,2$$\n",
    "\n",
    "The final Q Loss we will minimize is:\n",
    "\n",
    "$$Q_{Loss} = L(\\phi_1, {\\mathcal D}) + L(\\phi_1, {\\mathcal D})$$\n",
    "\n",
    "\n",
    "\n",
    "#### Policy Loss with Reparameterization Trick\n",
    "\n",
    "The policy should choose actions to maximize the expected future return and future entropy i.e. V^\\pi\\left(s\\right):\n",
    "\n",
    "$$V^\\pi\\left(s\\right)= \\underset{a\\sim\\pi}{E}[Q^\\pi\\left(s,a\\right)+\\alpha H\\left(\\pi\\left(\\cdot\\middle| s\\right)\\right)]$$\n",
    "\n",
    "We rewrite this as:\n",
    "\n",
    "$$V^\\pi\\left(s\\right)= \\underset{a\\sim\\pi}{E}[Q^\\pi\\left(s,a\\right)\\ -\\ \\alpha\\ log\\ \\pi\\left(a\\middle| s\\right)]$$\n",
    "\n",
    "The Authors of the paper, use reparameterization along with squashed Gaussian policy:\n",
    "\n",
    "$$\\tilde{a_\\theta}\\left(s,\\xi\\right)=\\tanh{\\left(\\mu_\\theta\\left(s\\right)+\\sigma_\\theta\\left(s\\right)\\odot\\xi\\right)},\\;\\;\\;\\;\\;\\xi\\sim\\mathcal{N}\\left(0,I\\right)$$\n",
    "\n",
    "Combining last two equations, and also noting that our policy network is parameterized by θ, the policy network weights, we get:\n",
    "\n",
    "$$\\underset{a \\sim \\pi_{\\theta}}{E}[{Q^{\\pi_{\\theta}}(s,a) - \\alpha \\log \\pi_{\\theta}(a|s)}] = \\underset{\\xi \\sim \\mathcal{N}}{E}[{Q^{\\pi_{\\theta}}(s,\\tilde{a}_{\\theta}(s,\\xi)) - \\alpha \\log \\pi_{\\theta}(\\tilde{a}_{\\theta}(s,\\xi)|s)}]$$\n",
    "\n",
    "\n",
    "Next, we substitute the function approximator for Q taking min of the two Q-functions. \n",
    "\n",
    "$$ Q^{\\pi_{\\theta}}(s,\\tilde{a}_{\\theta}(s,\\xi)) = \\min_{i=1,2} Q_{\\phi_i}(s,\\tilde{a}_{\\theta}(s,\\xi))$$\n",
    "\n",
    "The Policy Objective is given by:\n",
    "\n",
    "$$\\max_{\\theta} \\underset{s \\sim \\mathcal{D} \\\\ \\xi \\sim \\mathcal{N}}{E}\\left[ {\\min_{i=1,2} Q_{\\phi_i}(s,\\tilde{a}_{\\theta}(s,\\xi)) - \\alpha \\log \\pi_{\\theta}(\\tilde{a}_{\\theta}(s,\\xi)|s)} \\right]$$\n",
    "\n",
    "Like before, we use minimizers in PyTorch/TensorFlow. Accordingly, we introduce a -ve sign to convert maximization to a Loss minimization:\n",
    "\n",
    "$$Policy_{Loss} = - \\underset{s \\sim \\mathcal{D} \\\\ \\xi \\sim \\mathcal{N}}{E}\\left[ {\\min_{i=1,2} Q_{\\phi_i}(s,\\tilde{a}_{\\theta}(s,\\xi)) - \\alpha \\log \\pi_{\\theta}(\\tilde{a}_{\\theta}(s,\\xi)|s)} \\right]$$\n",
    "\n",
    "Next we convert the expectation to estimate using samples to get:\n",
    "\n",
    "$$Policy_{Loss} = - \\frac{1}{|B|}\\sum_{s \\in B} \\left(\\min_{i=1,2} Q_{\\phi_i}(s, \\tilde{a}_{\\theta}(s)) - \\alpha \\log \\pi_{\\theta} \\left(\\left. \\tilde{a}_{\\theta}(s) \\right| s\\right) \\right)$$\n",
    "\n",
    "\n",
    "You can read more about Reparameterization and Stochastic Graphs in [Gradient Estimation Using\n",
    "Stochastic Computation Graphs](https://arxiv.org/pdf/1506.05254.pdf)\n",
    "\n",
    "\n",
    "\n",
    "***\n",
    "**Soft Actor Critic (SAC)**\n",
    "***\n",
    " \n",
    "1. Input initial policy parameters $\\theta$,  Q-function parameters $\\phi_1$ and $\\phi_2$, empty replay buffer D\n",
    "\n",
    "2. Set target parameters equal to online parameters $\\phi_{targ,1} \\leftarrow \\phi_1$ and $\\phi_{targ,2} \\leftarrow \\phi_2$\n",
    "\n",
    "3. **repeat**\n",
    "\n",
    "4. Observe state s and select action $a \\sim \\pi_{\\theta}(\\cdot|s)$\n",
    "\n",
    "5. Execute a in environment and observe next state s', reward r, and done signal d\n",
    "\n",
    "6. Store `(s,a,r,s',d)` in Replay Buffer D\n",
    "\n",
    "7. if `s'` is terminal state, reset the environment\n",
    "\n",
    "8. if it's time to update **then**:\n",
    "\n",
    "9. &emsp;&emsp;for j in range (as many updates as required):\n",
    "\n",
    "10. &emsp;&emsp;&emsp;&emsp;Sample a batch B={`(s,a,r,s',d)`} from replay Buffer D:\n",
    "\n",
    "11. &emsp;&emsp;&emsp;&emsp;Compute target for Q functions: \n",
    "\n",
    "$$y (r,s',d) = r + \\gamma (1-d) \\left(\\min_{i=1,2} Q_{\\phi_{\\text{targ}, i}} (s', \\tilde{a}') - \\alpha \\log \\pi_{\\theta}(\\tilde{a}'|s')\\right), \\;\\;\\; \\tilde{a}' \\sim \\pi_{\\theta}(\\cdot|s')$$\n",
    "\n",
    "12. &emsp;&emsp;&emsp;&emsp;Update Q function with one step gradient descent on $\\phi$:\n",
    "$$\\nabla_{\\phi_i} \\frac{1}{|B|}\\sum_{(s,a,r,s',d) \\in B} \\left( Q_{\\phi_i}(s,a) - y(r,s',d) \\right)^2, \\;\\;\\;\\;\\; \\text{for } i=1,2$$\n",
    "\n",
    "13. &emsp;&emsp;&emsp;&emsp;Update policy by one step of gradient ascent using:\n",
    "$$\\nabla_{\\theta} \\frac{1}{|B|}\\sum_{s \\in B} \\left(\\min_{i=1,2} Q_{\\phi_i}(s, \\tilde{a}_{\\theta}(s)) - \\alpha \\log \\pi_{\\theta} \\left(\\left. \\tilde{a}_{\\theta}(s) \\right| s\\right) \\right)$$\n",
    "                      \n",
    "&emsp;&emsp;&emsp;&emsp;&emsp;&emsp;where $\\tilde{a}_{\\theta}(s)$ is a sample from $\\pi_{\\theta}(\\cdot|s)$ which is differentiable wrt $\\theta$ via the reparameterization trick.\n",
    "\n",
    "14. &emsp;&emsp;&emsp;&emsp;&emsp;&emsp;Update target networks using polyak averaging: \n",
    "$$\\phi_{targ,i} \\leftarrow \\rho\\phi_{targ,i} + (1-\\rho)\\phi_i, \\;\\;\\;\\;\\;  \\text{for } i=1,2$$ \n",
    "***\n",
    "\n",
    "\n",
    "#### Key Features of SAC\n",
    "\n",
    "1. SAC is an off-policy algorithm.\n",
    "2. SAC as implemented can only be used for environments with continuous action spaces. To apply SAC for discrete action space one needs to use Gumbel-Softmax distribution, You can find more about it online.\n",
    "3. SAC learns stochastic policies and is seen as extension of Actor Critic family. \n",
    "\n",
    "\n",
    "\n",
    "#### Our Implementation\n",
    "This notebook follows the code found in OpenAI's [Spinning Up Library](https://spinningup.openai.com/en/latest/algorithms/sac.html). In this notebook we have broken the code into separate code cells with required explanations. Also some of the implementations like ReplayBuffer have been borrowed from our past notebooks to provide continuity. Further some codes like building of networks have been simplified resulting in easier to understand but more verbose code. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.signal\n",
    "import matplotlib.pyplot as plt\n",
    "import itertools\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.optim import Adam\n",
    "from torch.distributions.normal import Normal\n",
    "\n",
    "from copy import deepcopy\n",
    "import gym\n",
    "\n",
    "\n",
    "import os\n",
    "import io\n",
    "import base64\n",
    "import time\n",
    "import glob\n",
    "from IPython.display import HTML\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environment - Pendulum\n",
    "\n",
    "We can use the setup here to run on any environment which has state as a single vector and actions are continuous. We will build it on `Pendulum-v0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_env(env_name, seed=None):\n",
    "    # remove time limit wrapper from environment\n",
    "    env = gym.make(env_name).unwrapped\n",
    "    if seed is not None:\n",
    "        env.seed(seed)\n",
    "    return env"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "State shape: (3,)\n",
      "Action shape: (1,)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "env_name = 'Pendulum-v0'\n",
    "\n",
    "env = make_env(env_name)\n",
    "env.reset()\n",
    "plt.imshow(env.render(\"rgb_array\"))\n",
    "state_shape, action_shape = env.observation_space.shape, env.action_space.shape\n",
    "print('State shape: {}'.format(state_shape))\n",
    "print('Action shape: {}'.format(action_shape))\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Policy network (Actor)\n",
    "It is a simple 2 hidden layer network which takes state as input and produces the mean $\\mu$ and $\\log(\\sigma)$ of a normal distribution from which actions are sampled. Calculating $logprob$ requires understanding reparameterization of density distributions, a short explanation is given in Appendix C of the SAC paper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "LOG_STD_MAX = 2\n",
    "LOG_STD_MIN = -20\n",
    "\n",
    "class SquashedGaussianMLPActor(nn.Module):\n",
    "    def __init__(self, state_dim, act_dim, act_limit):\n",
    "        super().__init__()\n",
    "        self.act_limit = act_limit\n",
    "        self.fc1 = nn.Linear(state_dim, 256)\n",
    "        self.fc2 = nn.Linear(256, 256)\n",
    "        self.mu_layer = nn.Linear(256, act_dim)\n",
    "        self.log_std_layer = nn.Linear(256, act_dim)\n",
    "        self.act_limit = act_limit\n",
    "    \n",
    "    def forward(self, s, deterministic=False, with_logprob=True):\n",
    "        x = self.fc1(s)\n",
    "        x = F.relu(x)\n",
    "        x = self.fc2(x)\n",
    "        x = F.relu(x)\n",
    "        mu = self.mu_layer(x)\n",
    "        log_std = self.log_std_layer(x)\n",
    "        log_std = torch.clamp(log_std, LOG_STD_MIN, LOG_STD_MAX)\n",
    "        std = torch.exp(log_std)\n",
    "        \n",
    "        # Pre-squash distribution and sample\n",
    "        pi_distribution = Normal(mu, std)\n",
    "        if deterministic:\n",
    "            # Only used for evaluating policy at test time.\n",
    "            pi_action = mu\n",
    "        else:\n",
    "            pi_action = pi_distribution.rsample()\n",
    "\n",
    "        if with_logprob:\n",
    "            # Compute logprob from Gaussian, and then apply correction for Tanh squashing.\n",
    "            # NOTE: The correction formula is a little bit magic. To get an understanding \n",
    "            # of where it comes from, check out the original SAC paper (arXiv 1801.01290) \n",
    "            # and look in appendix C. This is a more numerically-stable equivalent to Eq 21.\n",
    "            # Try deriving it yourself as a (very difficult) exercise. :)\n",
    "            logp_pi = pi_distribution.log_prob(pi_action).sum(axis=-1)\n",
    "            logp_pi -= (2*(np.log(2) - pi_action - F.softplus(-2*pi_action))).sum(axis=1)\n",
    "        else:\n",
    "            logp_pi = None\n",
    "\n",
    "        pi_action = torch.tanh(pi_action)\n",
    "        pi_action = self.act_limit * pi_action\n",
    "\n",
    "        return pi_action, logp_pi    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Q-network network (Critic)\n",
    "It is a simple 2 hidden layer network which takes state and action as input and produces Q-value as output. We will have two versions of Q-network as Critic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MLPQFunction(nn.Module):\n",
    "    def __init__(self, state_dim, act_dim):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(state_dim+act_dim, 256)\n",
    "        self.fc2 = nn.Linear(256, 256)\n",
    "        self.Q = nn.Linear(256, 1)\n",
    "    \n",
    "    def forward(self, s, a):\n",
    "        x = torch.cat([s,a], dim=-1)\n",
    "        x = self.fc1(x)\n",
    "        x = F.relu(x)\n",
    "        x = self.fc2(x)\n",
    "        x = F.relu(x)\n",
    "        q = self.Q(x)\n",
    "        return torch.squeeze(q, -1)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combine Actor and Critic into a single model\n",
    "\n",
    "One policy Network and Two Q-networks as discussed above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MLPActorCritic(nn.Module):\n",
    "    def __init__(self, observation_space, action_space):\n",
    "        super().__init__()\n",
    "        self.state_dim = observation_space.shape[0]\n",
    "        self.act_dim = action_space.shape[0]\n",
    "        self.act_limit = action_space.high[0]\n",
    "        \n",
    "        #build Q and policy functions\n",
    "        self.q1 = MLPQFunction(self.state_dim, self.act_dim)\n",
    "        self.q2 = MLPQFunction(self.state_dim, self.act_dim)\n",
    "        self.policy = SquashedGaussianMLPActor(self.state_dim, self.act_dim, self.act_limit)\n",
    "        \n",
    "    def act(self, state, deterministic=False):\n",
    "        with torch.no_grad():\n",
    "            a, _ = self.policy(state, deterministic, False)\n",
    "            return a.numpy()\n",
    "    \n",
    "    def get_action(self, state, deterministic=False):\n",
    "        return self.act(torch.as_tensor(state, dtype=torch.float32), \n",
    "                      deterministic)        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experience replay\n",
    "\n",
    "We will use the replay buffer we saw in chapter 4 listings. Replay buffer is very important in DQN to break the correlation between samples. We use a behavior policy ($\\epsilon-greedy$) to sample from the environment and store the transitions (s,a,r,s',done) into a buffer. These samples are used multiple times in a learning making the process sample efficient. \n",
    "\n",
    "The interface to ReplayBuffer is:\n",
    "* `exp_replay.add(state, action, reward, next_state, done)` - saves (s,a,r,s',done) tuple into the buffer\n",
    "* `exp_replay.sample(batch_size)` - returns states, actions, rewards, next_states and done_flags for `batch_size` random samples.\n",
    "* `len(exp_replay)` - returns number of elements stored in replay buffer.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    def __init__(self, size=1e6):\n",
    "        self.size = size #max number of items in buffer\n",
    "        self.buffer =[] #array to holde buffer\n",
    "        self.next_id = 0\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.buffer)\n",
    "    \n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        item = (state, action, reward, next_state, done)\n",
    "        if len(self.buffer) < self.size:\n",
    "            self.buffer.append(item)\n",
    "        else:\n",
    "            self.buffer[self.next_id] = item\n",
    "        self.next_id = (self.next_id + 1) % self.size\n",
    "        \n",
    "    def sample(self, batch_size=32):\n",
    "        idxs = np.random.choice(len(self.buffer), batch_size)\n",
    "        samples = [self.buffer[i] for i in idxs]\n",
    "        states, actions, rewards, next_states, done_flags = list(zip(*samples))\n",
    "        return np.array(states), np.array(actions), np.array(rewards), np.array(next_states), np.array(done_flags)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Q-loss\n",
    "\n",
    "Compute Q-loss as per equations above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def compute_q_loss(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma, alpha, act_limit):\n",
    "    \n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, dtype=torch.float)\n",
    "    actions = torch.tensor(actions, dtype=torch.float)\n",
    "    rewards = torch.tensor(rewards, dtype=torch.float)\n",
    "    next_states = torch.tensor(next_states, dtype=torch.float)\n",
    "    done_flags = torch.tensor(done_flags.astype('float32'),dtype=torch.float)\n",
    "    \n",
    "    # get q-values for all actions in current states\n",
    "    # use agent network\n",
    "    q1 = agent.q1(states, actions)\n",
    "    q2 = agent.q2(states, actions)\n",
    "    \n",
    "    # Bellman backup for Q function\n",
    "    with torch.no_grad():\n",
    "        \n",
    "        action_target, action_target_logp = target_network.policy(next_states)\n",
    "        \n",
    "        # Target Q            \n",
    "        q1_target = target_network.q1(next_states, action_target)\n",
    "        q2_target = target_network.q2(next_states, action_target)\n",
    "        q_target = torch.min(q1_target, q2_target) \n",
    "        target = rewards + gamma * (1 - done_flags) * (q_target-alpha*action_target_logp)\n",
    "\n",
    "    # MSE loss against Bellman backup\n",
    "    loss_q1 = ((q1 - target)**2).mean()\n",
    "    loss_q2 = ((q2 - target)**2).mean()\n",
    "    loss_q = loss_q1 + loss_q2\n",
    "    \n",
    "    return loss_q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Policy-Loss\n",
    "\n",
    "Compute Policy Loss as per equations above:\n",
    "    \n",
    "Please note the `-` sign. We need to do gradient ascent but PyTorch does gradient descent. We convert the ascent to descent using a -ve sign. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_policy_loss(agent, states, alpha):\n",
    "    \n",
    "    # convert numpy array to torch tensors\n",
    "    states = torch.tensor(states, dtype=torch.float)\n",
    "    \n",
    "    actions, actions_logp = agent.policy(states)\n",
    "    \n",
    "    q1_values = agent.q1(states, actions)\n",
    "    q2_values = agent.q2(states, actions)\n",
    "    q_values = torch.min(q1_values, q2_values)\n",
    "    \n",
    "    # Entropy regularised\n",
    "    loss_policy = - (q_values - alpha*actions_logp).mean()\n",
    "    return loss_policy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### One step gradient Descent on both Policy(Actor) and Q-value(Critic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def one_step_update(agent, target_network, q_params, q_optimizer, policy_optimizer, \n",
    "                    states, actions, rewards, next_states, done_flags,\n",
    "                    gamma, polyak, alpha, act_limit):\n",
    "    \n",
    "    #one step gradient for q-values\n",
    "    q_optimizer.zero_grad()\n",
    "    loss_q = compute_q_loss(agent, target_network, states, actions, rewards, next_states, done_flags,\n",
    "                    gamma, alpha, act_limit)\n",
    "    \n",
    "    loss_q.backward()\n",
    "    q_optimizer.step()\n",
    "    \n",
    "    #Freeze Q-network\n",
    "    for params in q_params:\n",
    "        params.requires_grad = False\n",
    "\n",
    "    #one setep gradient for policy network\n",
    "    policy_optimizer.zero_grad()\n",
    "    loss_policy = compute_policy_loss(agent, states, alpha)\n",
    "    loss_policy.backward()\n",
    "    policy_optimizer.step()\n",
    "\n",
    "    #UnFreeze Q-network\n",
    "    for params in q_params:\n",
    "        params.requires_grad = True\n",
    "\n",
    "\n",
    "    # update target networks with polyak averaging\n",
    "    with torch.no_grad():\n",
    "        for params, params_target in zip(agent.parameters(), target_network.parameters()):\n",
    "            params_target.data.mul_(polyak)\n",
    "            params_target.data.add_((1-polyak)*params.data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### To Test performance of agent without any stochasticity i.e. perform deterministic actions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_agent(env, agent, num_test_episodes, max_ep_len):\n",
    "    ep_rets, ep_lens = [], []\n",
    "    for j in range(num_test_episodes):\n",
    "        state, done, ep_ret, ep_len = env.reset(), False, 0, 0\n",
    "        while not(done or (ep_len == max_ep_len)):\n",
    "            # Take deterministic actions at test time \n",
    "            state, reward, done, _ = env.step(agent.get_action(state, True))\n",
    "            ep_ret += reward\n",
    "            ep_len += 1\n",
    "        ep_rets.append(ep_ret)\n",
    "        ep_lens.append(ep_len)\n",
    "    return np.mean(ep_rets), np.mean(ep_lens)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SAC Algorithm\n",
    "\n",
    "We pull all the pieces together to train the agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sac(env_fn, seed=0, \n",
    "         steps_per_epoch=4000, epochs=5, replay_size=int(1e6), gamma=0.99, \n",
    "         polyak=0.995, policy_lr=1e-3, q_lr=1e-3, alpha=0.2, batch_size=100, start_steps=10000, \n",
    "         update_after=1000, update_every=50, num_test_episodes=10, max_ep_len=1000):\n",
    "    \n",
    "    torch.manual_seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    \n",
    "    env, test_env = env_fn(), env_fn()\n",
    "    \n",
    "    ep_rets, ep_lens = [], []\n",
    "\n",
    "    state_dim = env.observation_space.shape\n",
    "    act_dim = env.action_space.shape[0]\n",
    "    \n",
    "    act_limit = env.action_space.high[0]\n",
    "    \n",
    "    agent = MLPActorCritic(env.observation_space, env.action_space)\n",
    "    target_network = deepcopy(agent)\n",
    "    \n",
    "    \n",
    "    # Freeze target networks with respect to optimizers (only update via polyak averaging)\n",
    "    for params in target_network.parameters():\n",
    "        params.requires_grad = False\n",
    "    \n",
    "    \n",
    "    # Experience buffer\n",
    "    replay_buffer = ReplayBuffer(replay_size)\n",
    "    \n",
    "    # List of parameters for both Q-networks \n",
    "    q_params = itertools.chain(agent.q1.parameters(), agent.q2.parameters())\n",
    "\n",
    "    #optimizers\n",
    "    q_optimizer = Adam(q_params, lr=q_lr)\n",
    "    policy_optimizer = Adam(agent.policy.parameters(), lr=policy_lr)\n",
    "    \n",
    "    total_steps = steps_per_epoch*epochs\n",
    "    state, ep_ret, ep_len = env.reset(), 0, 0\n",
    "    \n",
    "    for t in range(total_steps):\n",
    "        if t > start_steps:\n",
    "            action = agent.get_action(state)\n",
    "        else:\n",
    "            action = env.action_space.sample()\n",
    "            \n",
    "        next_state, reward, done, _ = env.step(action)\n",
    "        ep_ret += reward\n",
    "        ep_len += 1\n",
    "        \n",
    "        # Ignore the \"done\" signal if it comes from hitting the time\n",
    "        # horizon (that is, when it's an artificial terminal signal\n",
    "        # that isn't based on the agent's state)\n",
    "        done = False if ep_len==max_ep_len else done\n",
    "        \n",
    "        # Store experience to replay buffer\n",
    "        replay_buffer.add(state, action, reward, next_state, done)\n",
    "        \n",
    "        state = next_state\n",
    "        \n",
    "        # End of trajectory handling\n",
    "        if done or (ep_len == max_ep_len):\n",
    "            ep_rets.append(ep_ret)\n",
    "            ep_lens.append(ep_len)\n",
    "            state, ep_ret, ep_len = env.reset(), 0, 0\n",
    "        \n",
    "        # Update handling\n",
    "        if t >= update_after and t % update_every == 0:\n",
    "            for j in range(update_every):\n",
    "                states, actions, rewards, next_states, done_flags = replay_buffer.sample(batch_size)\n",
    "                \n",
    "                one_step_update(\n",
    "                        agent, target_network, q_params, q_optimizer, policy_optimizer, \n",
    "                        states, actions, rewards, next_states, done_flags,\n",
    "                        gamma, polyak, alpha, act_limit\n",
    "                )\n",
    "                        \n",
    "        # End of epoch handling\n",
    "        if (t+1) % steps_per_epoch == 0:\n",
    "            epoch = (t+1) // steps_per_epoch\n",
    "            \n",
    "            avg_ret, avg_len = test_agent(test_env, agent, num_test_episodes, max_ep_len)\n",
    "            print(\"End of epoch: {:.0f}, Training Average Reward: {:.0f}, Training Average Length: {:.0f}\".format(epoch, np.mean(ep_rets), np.mean(ep_lens)))\n",
    "            print(\"End of epoch: {:.0f}, Test Average Reward: {:.0f}, Test Average Length: {:.0f}\".format(epoch, avg_ret, avg_len))\n",
    "            ep_rets, ep_lens = [], []\n",
    "    \n",
    "    return agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train the agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "End of epoch: 1, Training Average Reward: -5068, Training Average Length: 1000\n",
      "End of epoch: 1, Test Average Reward: -255, Test Average Length: 1000\n",
      "End of epoch: 2, Training Average Reward: -6206, Training Average Length: 1000\n",
      "End of epoch: 2, Test Average Reward: -132, Test Average Length: 1000\n",
      "End of epoch: 3, Training Average Reward: -3609, Training Average Length: 1000\n",
      "End of epoch: 3, Test Average Reward: -173, Test Average Length: 1000\n",
      "End of epoch: 4, Training Average Reward: -157, Training Average Length: 1000\n",
      "End of epoch: 4, Test Average Reward: -165, Test Average Length: 1000\n",
      "End of epoch: 5, Training Average Reward: -95, Training Average Length: 1000\n",
      "End of epoch: 5, Test Average Reward: -149, Test Average Length: 1000\n"
     ]
    }
   ],
   "source": [
    "env_name = 'Pendulum-v0'\n",
    "agent = sac(lambda : make_env(env_name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Let us record a video of trained agent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_animation(env, agent, save_dir):\n",
    "    \n",
    "    try:\n",
    "        env = gym.wrappers.Monitor(\n",
    "            env, save_dir, video_callable=lambda id: True, force=True, mode='evaluation')\n",
    "    except gym.error.Error as e:\n",
    "        print(e)\n",
    "\n",
    "    if not os.path.exists(save_dir):\n",
    "        os.makedirs(save_dir)\n",
    "        \n",
    "    state, done, ep_ret, ep_len = env.reset(), False, 0, 0\n",
    "    while not done:\n",
    "        # Take deterministic actions at test time\n",
    "        state, reward, done, _ = env.step(agent.get_action(state, True))\n",
    "        ep_ret += reward\n",
    "        ep_len += 1\n",
    "\n",
    "    print('Reward: {}'.format(ep_ret))\n",
    "    env.close()\n",
    "            \n",
    "def display_animation(filepath):\n",
    "    video = io.open(filepath, 'r+b').read()\n",
    "    encoded = base64.b64encode(video)\n",
    "    return HTML(data='''<video alt=\"test\" controls>\n",
    "                <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\" />\n",
    "                 </video>'''.format(encoded.decode('ascii')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reward: -2.6907421772405864\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<video alt=\"test\" controls>\n",
       "                <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n",
       "                 </video>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Animate learned policy\n",
    "save_dir='./videos/pytorch/sac/pendulum'\n",
    "env = gym.make(env_name)\n",
    "generate_animation(env, agent, save_dir=save_dir)\n",
    "[filepath] = glob.glob(os.path.join(save_dir, '*.mp4'))\n",
    "display_animation(filepath)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Train and evaluate performance on LunarLander Environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "End of epoch: 1, Training Average Reward: -220, Training Average Length: 108\n",
      "End of epoch: 1, Test Average Reward: -66, Test Average Length: 436\n",
      "End of epoch: 2, Training Average Reward: -222, Training Average Length: 111\n",
      "End of epoch: 2, Test Average Reward: -14, Test Average Length: 280\n",
      "End of epoch: 3, Training Average Reward: -195, Training Average Length: 179\n",
      "End of epoch: 3, Test Average Reward: -136, Test Average Length: 312\n",
      "End of epoch: 4, Training Average Reward: -136, Training Average Length: 590\n",
      "End of epoch: 4, Test Average Reward: -142, Test Average Length: 581\n",
      "End of epoch: 5, Training Average Reward: -82, Training Average Length: 583\n",
      "End of epoch: 5, Test Average Reward: -15, Test Average Length: 631\n",
      "Reward: -100.36610279423913\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<video alt=\"test\" controls>\n",
       "                <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\" />\n",
       "                 </video>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Train\n",
    "env_name = 'LunarLanderContinuous-v2'\n",
    "agent1 = sac(lambda : make_env(env_name))\n",
    "\n",
    "# Animate learned policy\n",
    "save_dir='./videos/pytorch/sac/lunar'\n",
    "env = gym.make(env_name)\n",
    "generate_animation(env, agent1, save_dir=save_dir)\n",
    "[filepath] = glob.glob(os.path.join(save_dir, '*.mp4'))\n",
    "display_animation(filepath)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
